home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Commodities / Ascsend / MUI / Source / mui_ascs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  60.1 KB  |  1,797 lines
  1.  
  2. #include "mui_ascs.h"
  3.  
  4. int      CXBRK(void) { return(0); }
  5. int     _CXBRK(void) { return(0); }
  6. void    chkabort(void) {}
  7. long    __OSlibversion = 37;
  8.  
  9. /* ------------------------------------------------------------------- */
  10. /*      for cback.o startup */
  11. /* ------------------------------------------------------------------- */
  12.  
  13. long                      __stack        = 4096;
  14. char                      *__procname    = ASCSEND_VERSION;
  15. long                      __priority      = 0L;
  16. long                      __BackGroundIO = 0;
  17. extern BPTR               _Backstdout;
  18.  
  19. /********************************************************************/
  20. /*            Für den Filerequester                                 */
  21. /********************************************************************/
  22.  
  23. struct TagItem         FRTags[] =
  24.              {
  25.               ASL_Hail,(ULONG)"ASCII-SEND: Datei auswählen",
  26.               ASL_FuncFlags,0L,
  27.               ASL_Pattern,(ULONG)"~(#?.info)",
  28.               ASL_Dir,NULL,
  29.               ASL_File,NULL,
  30.               ASL_Window,NULL,
  31.               TAG_DONE,0L
  32.              };
  33.  
  34. /****************************************************************/
  35. /*                    Var's                                     */
  36. /****************************************************************/
  37.  
  38. struct Library *MUIMasterBase;
  39. struct Library *LocalBase;
  40.  
  41. enum IDs
  42.      {
  43.       ID_DUMMY,
  44.       ID_SAVE,
  45.       ID_INFO,
  46.       ID_LOAD,
  47.       ID_OPENWD,
  48.       ID_CLOSEWD,
  49.       ID_QUIT,
  50.       ID_INSERTFILE,
  51.       ID_FILESELECT,
  52.       ID_FILEREQ,
  53.       ID_CHANGE_FILEREQ,
  54.       ID_CHANGE_INFOREQ,
  55.       ID_CHANGE_POPKEY,
  56.       ID_CHANGE_STOPKEY,
  57.       ID_CHANGE_DELAY,
  58.       ID_CHANGE_DELAYCHAR,
  59.       ID_STOPKEY,
  60.       ID_QUIT_SILENT,
  61.       ID_DOUBLESTART,
  62.       ID_EDITFILE,
  63.       ID_RECSTART,
  64.       ID_RECSTOP,
  65.       ID_RECFILE,
  66.       ID_CHANGE_RECSTART,
  67.       ID_CHANGE_RECSTOP,
  68.       ID_CHANGE_HANDLER_PRI,
  69.       ID_EDIT_RECFILE,
  70.       ID_AUTORECSTART,
  71.       ID_AUTORECSTOP,
  72.       ID_AUTOHOTKEY,
  73.       ID_AUTOFILEREQKEY,
  74.       ID_AUTOPOPKEY,
  75.       ID_AUTOSTOPKEY,
  76.       ID_AUTOINFOKEY,
  77.      };
  78.  
  79. struct NewMenu menu_list[] =
  80. {
  81.  { NM_TITLE,NULL,0,0,0,0},
  82.  { NM_ITEM, NULL,"R",0,0,(APTR)ID_LOAD},
  83.  { NM_ITEM, NULL,"I",0,0,(APTR) ID_SAVE},
  84.  { NM_ITEM, NM_BARLABEL,0,0,0,0},
  85.  { NM_ITEM, NULL,"?",0,0,(APTR) ID_INFO},
  86.  { NM_ITEM, NM_BARLABEL,0,0,0,0},
  87.  { NM_ITEM, NULL, "H",0,0,(APTR) ID_CLOSEWD},  
  88.  { NM_ITEM, NULL, "Q",0,0,(APTR) ID_QUIT},
  89.  NULL,
  90. };
  91.  
  92.  
  93. UBYTE  displayline[STRMAXLEN]; 
  94. UBYTE  wtitle[STRMAXLEN];
  95. UBYTE  requestpath[STRMAXLEN];
  96. UBYTE  requestfile[STRMAXLEN];
  97.  
  98. struct hotkey   ins;
  99. struct hotkey  *insert_key = &ins;
  100. ULONG  from_inside;
  101. ULONG  signals;
  102. ULONG  NextID = CXID_BASE;
  103. ULONG filesize;
  104. ULONG filepos;
  105. struct Catalog *ascs_catalog;
  106. struct Locale  *ascs_locale;
  107. ULONG recording;
  108. ULONG from_main = FALSE;
  109. APTR  from_main_object;
  110.  
  111. struct IOStdReq  *s_HandlerIO;
  112. struct MsgPort   *s_InputPort;
  113. BYTE              s_device;
  114.  
  115. UBYTE *locale_strings[] =
  116.        {
  117.         "Projekt",
  118.         "Einstellungen zurücksetzen",
  119.         "Icon erzeugen",
  120.         "Info",
  121.         "Fenster schliessen",
  122.  /*5*/  "Beenden...",
  123.         "Datei auswählen...",
  124.         "Linke AMIGA-Taste",
  125.         "Rechte AMIGA-Taste",
  126.         "Keine ALT Taste",
  127.  /*10*/ "Jede ALT-Taste ",
  128.         "Linke ALT-Taste",
  129.         "Rechte ALT-Taste",
  130.         "Keine SHIFT Taste",
  131.         "Jede SHIFT-Taste",
  132.  /*15*/ "Linke SHIFT-Taste",
  133.         "Rechte SHIFT-Taste",
  134.         "Sendet Textfiles als InputEvents",
  135.         "Tasten",
  136.         "Übernehmen",
  137.  /*20*/ "Abbruch",
  138.         "Datei:",
  139.         "Edieren",
  140.         "Neu",
  141.         "Entfernen",
  142.  /*25*/ "Spezielle Tasten",
  143.         "Verzögerungen",
  144.         "Zeilen",
  145.         "Einzelzeichen",
  146.         "Ja|*Nein",
  147.  /*30*/ "Wirklich beenden ?",
  148.         "*Na gut",
  149.         "Beenden|*Weiter",
  150.         "Buchstaben",
  151.         "Aufnahme",
  152.  /*35*/ "Start",
  153.         "Stop",
  154.         "Datei",
  155.         "Min. Delay",
  156.         "Priorität",
  157.  /*40*/ "Mit Mausbuttons",
  158.         "Mit Pausen",
  159.         "Zeichen",
  160.         "Bitte eine Taste/Tastenkombination drücken",
  161.        };
  162. /*********************************************************************/
  163. /*                   Hooks                                           */
  164. /*********************************************************************/
  165.  
  166. struct Hook construct_keys = {
  167.     {NULL, NULL},
  168.     (void *)construct_key_func,
  169.     NULL, NULL
  170. };
  171.  
  172. struct Hook destruct_keys = {
  173.     {NULL, NULL},
  174.     (void *)destruct_key_func,
  175.     NULL, NULL
  176. };
  177.  
  178. struct Hook display_keys = {
  179.     {NULL, NULL},
  180.     (void *)display_key_func,
  181.     NULL, NULL
  182. };
  183.  
  184. struct Hook compare_keys = {
  185.     {NULL, NULL},
  186.     (void *)compare_func,
  187.     NULL, NULL
  188. };
  189.  
  190. struct Hook cxmsg = {
  191.         {NULL,NULL},
  192.         (void *)cxmsg_broker_func,
  193.         NULL,NULL
  194. };
  195.  
  196. struct Hook rx_send = {
  197.     {NULL, NULL},
  198.     (void *)rx_send_func,
  199.     NULL, NULL
  200. };
  201.  
  202. struct Hook rx_activate = {
  203.     {NULL, NULL},
  204.     (void *)rx_activate_func,
  205.     NULL, NULL
  206. };
  207.  
  208. struct Hook rx_activate_screen = {
  209.     {NULL, NULL},
  210.     (void *)rx_activate_screen_func,
  211.     NULL, NULL
  212. };
  213.  
  214. struct Hook rx_setkey = {
  215.     {NULL, NULL},
  216.     (void *)rx_setkey_func,
  217.     NULL, NULL
  218. };
  219. struct Hook rx_remkey = {
  220.     {NULL, NULL},
  221.     (void *)rx_remkey_func,
  222.     NULL, NULL
  223. };
  224.  
  225. struct Hook rx_remall = {
  226.     {NULL, NULL},
  227.     (void *)rx_remall_func,
  228.     NULL, NULL
  229. };
  230.  
  231. struct Hook rx_set = {
  232.     {NULL, NULL},
  233.     (void *)rx_set_func,
  234.     NULL, NULL
  235. };
  236. struct Hook rx_delay = {
  237.     {NULL, NULL},
  238.     (void *)rx_delay_func,
  239.     NULL, NULL
  240. };
  241.  
  242. struct Hook rx_delaychar = {
  243.     {NULL, NULL},
  244.     (void *)rx_delaychar_func,
  245.     NULL, NULL
  246. };
  247.  
  248. struct Hook rx_sendstring = {
  249.     {NULL, NULL},
  250.     (void *)rx_sendstring_func,
  251.     NULL, NULL
  252. };
  253.  
  254. struct Hook rx_recfile = {
  255.     {NULL, NULL},
  256.     (void *)rx_recfile_func,
  257.     NULL, NULL
  258. };
  259.  
  260. struct Hook rx_rec_opts = {
  261.     {NULL, NULL},
  262.     (void *)rx_rec_opts_func,
  263.     NULL, NULL
  264. };
  265.  
  266.  
  267. /*********************************************************************/
  268. /*                   Objekte                                         */
  269. /*********************************************************************/
  270.  
  271. APTR app;
  272. APTR window;
  273. APTR key_lv;
  274. APTR key_list; 
  275. APTR special_list;
  276. APTR newkey, newkeystring,delkey, filestring;
  277. APTR filerequest_string, popup_string, stop_string,info_string,popfile;
  278. APTR popfilebutton;
  279. APTR delay_int,delaychar_int;
  280. APTR pop_hotkey,popkey_button;
  281. APTR edit_button,edit_popup,edit_string;
  282. APTR rec_start,rec_stop,rec_file,pop_recfile;
  283. APTR rec_min_delay,rec_handler_pri,rec_include_mb,rec_include_delay;
  284. APTR edit_recfile,rec_max;
  285. APTR auto_recstart,auto_recstop;
  286. APTR press_a_key,t;
  287. APTR autopopkey,autoinfokey,autofilereqkey,autostopkey;
  288. APTR rec_max_on;
  289. /****************************************************************/
  290. /*              Arexx-Commands                                  */
  291. /****************************************************************/
  292.  
  293. struct MUI_Command rx_cmd[] =
  294.        {
  295.         {"activate_window" ,"WINDOW/A",1,&rx_activate},
  296.         {"activate_screen" ,"SCREEN/A",1,&rx_activate_screen},
  297.         {"closewindow"     ,MC_TEMPLATE_ID,ID_CLOSEWD,NULL},
  298.         {"delay"           ,"TICKS/N/A",1,&rx_delay},
  299.         {"delaychar"       ,"TICKS/N/A",1,&rx_delaychar},
  300.         {"infokey"         ,MC_TEMPLATE_ID,ID_INFO,NULL},
  301.         {"openwindow"      ,MC_TEMPLATE_ID,ID_OPENWD,NULL},
  302.         {"saveicon"        ,MC_TEMPLATE_ID,ID_SAVE,NULL},
  303.         {"send"            ,"FILE/A",1,&rx_send},
  304.         {"string"          ,"STRING/M/A",1,&rx_sendstring},
  305.         {"set"             ,"POPKEY/S,REQUESTKEY/S,INFOKEY/S,STOPKEY/S,RECSTARTKEY/S,RECSTOPKEY/S,KEY/M/A",7,&rx_set},
  306.         {"setkey"          ,"FILE/A,KEY/M/A",2,&rx_setkey},
  307.         {"stopkey"         ,MC_TEMPLATE_ID,ID_STOPKEY,NULL},
  308.         {"remove"          ,"KEY/M/A",1,&rx_remkey},
  309.         {"remove_all"      ,"",0,&rx_remall},
  310.         {"reset"           ,MC_TEMPLATE_ID,ID_LOAD,NULL},
  311.         {"requestkey"      ,MC_TEMPLATE_ID,ID_FILEREQ,NULL},
  312.         {"start_rec"       ,MC_TEMPLATE_ID,ID_RECSTART,NULL},
  313.         {"stop_rec"        ,MC_TEMPLATE_ID,ID_RECSTOP,NULL},
  314.         {"recfile"         ,"FILE/M/A",1,&rx_recfile},
  315.         {"rec_options"     ,"MIN_DELAY/N,PRI/N,MOUSEBUTTONS/S,DELAYS/S,MAXCHAR/N,ON/S",4,&rx_rec_opts},
  316.         {NULL,NULL,NULL,NULL}
  317.        };
  318.  
  319. /*********************************************************************/
  320. /*               Main                                                */
  321. /*********************************************************************/
  322.  
  323. void __stdargs main(int argc,char **argv)
  324. {
  325.  BOOL running = TRUE;
  326.  init();
  327.  
  328.  /*******************************************************************/
  329.  /*                  Objekte erstellen                              */
  330.  /*******************************************************************/
  331.  
  332.  app = ApplicationObject,
  333.         MUIA_Application_Title        , "ASCII_SEND",
  334.         MUIA_Application_Version    , ASCSEND_VERSION,
  335.         MUIA_Application_Copyright  , "FREEWARE von Lunqal%%MAB@wsb.freinet.de",
  336.         MUIA_Application_Author     , "Dr. Flame (VEG)Lunqual",
  337.         MUIA_Application_Description, GETSTR(17),
  338.         MUIA_Application_Base        , "ASCSEND",
  339.                 MUIA_Application_Menu, menu_list,
  340.                 MUIA_Application_BrokerHook, &cxmsg,
  341.                 MUIA_Application_SingleTask, TRUE,
  342.                 MUIA_Application_Commands  , rx_cmd,
  343.   Child,special_list = ListObject,
  344.    MUIA_List_ConstructHook, &construct_keys,
  345.    MUIA_List_DestructHook,  &destruct_keys,
  346.   End,
  347.   SubWindow, press_a_key = WindowObject,
  348.    MUIA_Window_Title, "Taste ?",
  349.    MUIA_Window_ID   , 'TAST',
  350.    WindowContents, VGroup,GroupFrame,
  351.     Child, t = TextObject,
  352.      TextFrame,
  353.      MUIA_Text_Contents,GETSTR(43),
  354.     End,
  355.    End,
  356.   End,
  357.   SubWindow, window= WindowObject,
  358.    MUIA_Window_Title, ASCSEND_TEXT,
  359.    MUIA_Window_ID   , 'ASCS',
  360.    WindowContents, VGroup,
  361.     Child,HGroup,
  362.      MUIA_Group_SameSize,TRUE,
  363.      Child, VGroup,GroupFrameT("Hotkeys & Files"),
  364.       Child,VGroup,
  365.        Child, key_lv = ListviewObject,
  366.         ReadListFrame,
  367.         MUIA_Listview_Input,TRUE,
  368.         MUIA_Listview_List, key_list = ListObject,
  369.          MUIA_List_ConstructHook, &construct_keys,
  370.          MUIA_List_DestructHook,  &destruct_keys,
  371.          MUIA_List_CompareHook,   &compare_keys,
  372.          MUIA_List_DisplayHook,   &display_keys,
  373.          End,
  374.        End,
  375.        Child, VGroup, GroupFrame,
  376.         Child, ColGroup(3),
  377.          Child, KeyLabel2("Hotkey:",'y'),
  378.          Child, newkeystring = KeyString(0,STRMAXLEN,'y'),
  379.          Child, popkey_button = PopButton(MUII_PopUp),
  380.         End,
  381.         Child,ColGroup(2),
  382.          Child, KeyLabel2(GETSTR(21),'d'),
  383.                         Child, popfile = PopaslObject,
  384.                             MUIA_Popstring_String, filestring    = KeyString(0,STRMAXLEN,'d'),
  385.                             MUIA_Popstring_Button, popfilebutton = PopButton(MUII_PopFile),
  386.                             ASLFR_TitleText, GETSTR(6),
  387.                            End,
  388.         End,
  389.         Child,VGroup,
  390.          Child,HGroup,
  391.           Child, edit_button =  KeyButton(GETSTR(22),'r'),
  392.           Child, edit_popup = PopaslObject,
  393.                              MUIA_Popstring_String, edit_string   = KeyString(0,STRMAXLEN,'i'),
  394.                              MUIA_Popstring_Button, edit_popup = PopButton(MUII_PopFile),
  395.                              ASLFR_TitleText, GETSTR(6),
  396.                             End,
  397.          End,
  398.          Child,HGroup,
  399.           Child, newkey = KeyButton(GETSTR(23),'n'),
  400.           Child, delkey = KeyButton(GETSTR(24),'e'), 
  401.          End,
  402.         End,
  403.        End,
  404.       End,
  405.      End,
  406.      Child,VGroup,
  407.       Child, VGroup, GroupFrameT(GETSTR(34)),
  408.        Child,ColGroup(3),
  409.         Child, Label2(GETSTR(35)),  
  410.         Child, rec_start = String("",STRMAXLEN),
  411.         Child, auto_recstart = PopButton(MUII_PopUp),
  412.         Child, Label2(GETSTR(36)),  
  413.         Child, rec_stop  = String("",STRMAXLEN),
  414.         Child, auto_recstop = PopButton(MUII_PopUp),
  415.        End,               
  416.        Child,ColGroup(2),
  417.         Child, Label2(GETSTR(37)),
  418.         Child, pop_recfile = PopaslObject,
  419.                         MUIA_Popstring_String, rec_file      = KeyString(0,STRMAXLEN,'r'),
  420.                         MUIA_Popstring_Button, PopButton(MUII_PopFile),
  421.                         ASLFR_TitleText, GETSTR(6),
  422.                        End,
  423.        End,
  424.        Child, edit_recfile = ButtonObject(GETSTR(22)), 
  425.        Child,ColGroup(2), 
  426.         Child, Label2(GETSTR(38)),
  427.         Child, rec_min_delay = IntegerObject("25",4),
  428.         Child, Label2(GETSTR(39)),
  429.         Child, rec_handler_pri = IntegerObject("60",3),
  430.        End,
  431.        Child, ColGroup(3),
  432.         Child, Label2(GETSTR(42)),
  433.         Child, rec_max         = IntegerObject("0",10),
  434.         Child, rec_max_on      = CheckMark(FALSE),
  435.        End,
  436.        Child,ColGroup(4),
  437.         Child, Label2(GETSTR(40)),
  438.         Child, rec_include_mb = CheckMark(TRUE),
  439.         Child, Label2(GETSTR(41)),
  440.         Child, rec_include_delay = CheckMark(TRUE),
  441.        End,
  442.       End,
  443.      End,
  444.      Child,HGroup,GroupFrameT(GETSTR(25)),
  445.       Child, VGroup,
  446.        Child, ColGroup(3),
  447.         Child,Label2("\33uF\33nilerequester"),
  448.         Child,filerequest_string = KeyString("",KEYLEN,'f'),
  449.         Child,autofilereqkey = PopButton(MUII_PopUp),
  450.         Child,Label2("\33uS\33ntopkey"),
  451.         Child,stop_string = KeyString("",KEYLEN,'s'),
  452.         Child,autostopkey = PopButton(MUII_PopUp),
  453.         Child,Label2("\33uI\33nnfo"),
  454.         Child,info_string = KeyString("",KEYLEN,'i'),
  455.         Child,autoinfokey = PopButton(MUII_PopUp),
  456.         Child,Label2("\33uC\33nX_Popkey"),
  457.         Child,popup_string = KeyString("",KEYLEN,'c'),
  458.         Child,autopopkey = PopButton(MUII_PopUp),
  459.        End,
  460.        Child,VGroup,GroupFrameT(GETSTR(26)),
  461.         Child,ColGroup(2),
  462.          Child,Label2(GETSTR(27)),
  463.          Child,delay_int = MyKeyInteger(KEYLEN,'z'),
  464.          Child,Label2(GETSTR(28)),
  465.          Child,delaychar_int = MyKeyInteger(KEYLEN,'h'),
  466.         End,
  467.        End,
  468.       End,
  469.      End,
  470.     End,  
  471.    End,
  472.   End,
  473.  End;
  474.  /******************************************************************/
  475.  /*           Objekte erstellt (oda eben nich)                     */
  476.  /******************************************************************/
  477.  
  478.  if(!app)fail(NULL);
  479.  Load_from_icon(argc,argv);
  480.  if(!init_recorder())fail(app); 
  481.  /******************************************************************/
  482.  /*                Methoden                                        */
  483.  /******************************************************************/
  484.  /*          Fenster schliessen                                    */
  485.  /******************************************************************/
  486.  DoMethod(window,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,app,2,MUIM_Application_ReturnID,ID_CLOSEWD);
  487.  
  488.  /*******************************************************************/
  489.  /*        Die ganzen String & Integergadgets                       */
  490.  /*******************************************************************/
  491.  
  492.  DoMethod(filerequest_string,MUIM_Notify,MUIA_String_Acknowledge,
  493.           MUIV_EveryTime,app,2,MUIM_Application_ReturnID,ID_CHANGE_FILEREQ);
  494.  DoMethod(stop_string,MUIM_Notify,MUIA_String_Acknowledge,
  495.           MUIV_EveryTime,app,2,MUIM_Application_ReturnID,ID_CHANGE_STOPKEY);
  496.  DoMethod(info_string,MUIM_Notify,MUIA_String_Acknowledge,
  497.           MUIV_EveryTime,app,2,MUIM_Application_ReturnID,ID_CHANGE_INFOREQ);
  498.  DoMethod(popup_string,MUIM_Notify,MUIA_String_Acknowledge,
  499.           MUIV_EveryTime,app,2,MUIM_Application_ReturnID,ID_CHANGE_POPKEY);          
  500.  DoMethod(rec_start,MUIM_Notify,MUIA_String_Acknowledge,
  501.           MUIV_EveryTime,app,2,MUIM_Application_ReturnID,ID_CHANGE_RECSTART);  
  502.  DoMethod(rec_stop,MUIM_Notify,MUIA_String_Acknowledge,
  503.           MUIV_EveryTime,app,2,MUIM_Application_ReturnID,ID_CHANGE_RECSTOP);  
  504.  DoMethod(rec_handler_pri,MUIM_Notify,MUIA_String_Acknowledge,
  505.           MUIV_EveryTime,app,2,MUIM_Application_ReturnID,ID_CHANGE_HANDLER_PRI);  
  506.  
  507.  DoMethod(auto_recstart,MUIM_Notify,MUIA_Pressed,FALSE,
  508.          app,2,MUIM_Application_ReturnID,ID_AUTORECSTART);
  509.  
  510.  DoMethod(auto_recstop,MUIM_Notify,MUIA_Pressed,FALSE,
  511.          app,2,MUIM_Application_ReturnID,ID_AUTORECSTOP);
  512.  
  513.  DoMethod(popkey_button,MUIM_Notify,MUIA_Pressed,FALSE,
  514.           app,2,MUIM_Application_ReturnID,ID_AUTOHOTKEY);
  515.   
  516.  DoMethod(autostopkey,MUIM_Notify,MUIA_Pressed,FALSE,
  517.           app,2,MUIM_Application_ReturnID,ID_AUTOSTOPKEY);
  518.  
  519.  DoMethod(autofilereqkey,MUIM_Notify,MUIA_Pressed,FALSE,
  520.           app,2,MUIM_Application_ReturnID,ID_AUTOFILEREQKEY);
  521.  
  522.  DoMethod(autoinfokey,MUIM_Notify,MUIA_Pressed,FALSE,
  523.           app,2,MUIM_Application_ReturnID,ID_AUTOINFOKEY);
  524.  
  525.  DoMethod(autopopkey,MUIM_Notify,MUIA_Pressed,FALSE,
  526.           app,2,MUIM_Application_ReturnID,ID_AUTOPOPKEY);
  527.  
  528.  /******************************************************************/
  529.  /*             die Fileliste                                      */
  530.  /******************************************************************/
  531.  
  532.  
  533.  DoMethod(newkey,MUIM_Notify,MUIA_Pressed,FALSE,
  534.          app,2,MUIM_Application_ReturnID,ID_INSERTFILE);
  535.  
  536.  
  537.  DoMethod(key_list,MUIM_Notify,MUIA_List_Active,MUIV_EveryTime,
  538.              app,2,MUIM_Application_ReturnID,ID_FILESELECT);
  539.  
  540.  
  541.  DoMethod(delkey,MUIM_Notify,MUIA_Pressed,FALSE,
  542.              key_list,2,MUIM_List_Remove,MUIV_List_Remove_Active);                
  543.  
  544.  /******************************************************************/
  545.  /* popobject */
  546.  /*************/    
  547.   
  548.  DoMethod(window,MUIM_Window_SetCycleChain,
  549.           key_lv,newkeystring,popkey_button,filestring,popfilebutton,newkey,
  550.           rec_start,rec_start,auto_recstart,rec_stop,auto_recstop,
  551.           rec_file,pop_recfile,edit_recfile,rec_min_delay,rec_handler_pri,
  552.           rec_max,rec_max_on,rec_include_mb,rec_include_delay,
  553.           filerequest_string,autofilereqkey,stop_string,autostopkey,
  554.           info_string,autoinfokey,popup_string,autopopkey,
  555.           delay_int,delaychar_int,
  556.           NULL);
  557.                
  558.  set(window,MUIA_Window_ActiveObject,key_lv);
  559.  /******************************************************************/
  560.  /*       Grummel.........vagesslich werd ich 8(((((               */
  561.  /******************************************************************/
  562.  
  563.  DoMethod(app,MUIM_Notify,MUIA_Application_DoubleStart,MUIV_EveryTime,
  564.       app,2,MUIM_Application_ReturnID,ID_DOUBLESTART);
  565.  
  566.  DoMethod(edit_button, MUIM_Notify,MUIA_Pressed,FALSE,
  567.           app,2,MUIM_Application_ReturnID,ID_EDITFILE);
  568.  
  569.  DoMethod(edit_recfile, MUIM_Notify,MUIA_Pressed,FALSE,
  570.           app,2,MUIM_Application_ReturnID,ID_EDIT_RECFILE);
  571.  
  572.  
  573.  /******************************************************************/
  574.  /*              muss auch sein....;-)                             */
  575.  /******************************************************************/
  576.  
  577.  ShowWDTitle();
  578.  while (running)
  579.  {
  580.   switch (DoMethod(app,MUIM_Application_Input,&signals))
  581.   {
  582.    case ID_CLOSEWD                     : CLOSEWD_MACRO;
  583.                                          break;
  584.    case ID_QUIT_SILENT                 : running = FALSE;
  585.                                          break;
  586.    case ID_LOAD                        : Load_from_icon(argc,argv);
  587.                                          break;
  588.    case ID_SAVE                        : Save_to_icon();
  589.                                          break;
  590.    case MUIV_Application_ReturnID_Quit :
  591.    case ID_QUIT                        : {
  592.                                           ULONG o;
  593.                                           get(window,MUIA_Window_Open,&o);
  594.                                           if(o)
  595.                                           {
  596.                                            if(MUI_RequestA(app,NULL,0,NULL,GETSTR(29),
  597.                                               GETSTR(30),NULL) != 0)running = FALSE;
  598.                                           }
  599.                                           else running = FALSE;
  600.                                          }
  601.                                          break;
  602.    case ID_INFO                        : MUI_RequestA(app,NULL,0,NULL,GETSTR(31),"\33c" ASCSEND_VERSION "\n FREEWARE by Lunqual%%MAB@wsb.freinet.de\n",NULL);
  603.                                          break;    
  604.    case ID_CHANGE_POPKEY               : {
  605.                                           UBYTE *str;
  606.                                           get(popup_string,MUIA_String_Contents,&str);
  607.                                           ChangeKey(special_list,str,NULL,CXID_POPUP,MODE_CHANGE);
  608.                                           ShowWDTitle();
  609.                                          }
  610.                                          break;     
  611.    case ID_CHANGE_STOPKEY              : {
  612.                                           UBYTE *str;
  613.                                           get(stop_string,MUIA_String_Contents,&str);
  614.                                           ChangeKey(special_list,str,NULL,CXID_STOP,MODE_CHANGE);
  615.                                          }
  616.                                          break;     
  617.    case ID_CHANGE_FILEREQ              : {
  618.                                           UBYTE *str;
  619.                                           get(filerequest_string,MUIA_String_Contents,&str);
  620.                                           ChangeKey(special_list,str,NULL,CXID_FILEREQ,MODE_CHANGE);
  621.                                          }
  622.                                          break;     
  623.    case ID_CHANGE_INFOREQ              : {
  624.                                           UBYTE *str;
  625.                                           get(info_string,MUIA_String_Contents,&str);
  626.                                           ChangeKey(special_list,str,NULL,CXID_INFO,MODE_CHANGE);
  627.                                          }
  628.                                          break; 
  629.    case ID_CHANGE_RECSTART             : {
  630.                                           UBYTE *str;
  631.                                           get(rec_start,MUIA_String_Contents,&str);
  632.                                           ChangeKey(special_list,str,NULL,CXID_RECSTART,MODE_CHANGE);  
  633.                                          }
  634.                                          break;   
  635.    case ID_CHANGE_RECSTOP              : {
  636.                                           UBYTE *str;
  637.                                           get(rec_stop,MUIA_String_Contents,&str);
  638.                                           ChangeKey(special_list,str,NULL,CXID_RECSTOP,MODE_CHANGE);  
  639.                                          }
  640.                                          break;   
  641.    case ID_INSERTFILE                  : {
  642.                                           UBYTE *key,*file;
  643.                                           get(newkeystring,MUIA_String_Contents,&key);
  644.                                           get(filestring,MUIA_String_Contents,&file);
  645.                                           if(*file && *key)
  646.                                           {
  647.                                            struct hotkey *k;
  648.                                            if(k = FindEntryKey(key_list,key))
  649.                                            {
  650.                                             strcpy(k->h_filename,file);
  651.                                            }
  652.                                            else
  653.                                              ChangeKey(key_list,key,file,NextID,MODE_CHANGE);
  654.                                           }
  655.                                          }
  656.                                          break;
  657.    case ID_FILESELECT                  : {
  658.                                           struct hotkey *key;
  659.                                           ULONG n;
  660.                                           get(key_list,MUIA_List_Active,&n);
  661.                                           if(key = FindEntryN(key_list,n))
  662.                                           {
  663.                                            set(newkeystring,MUIA_String_Contents,key->h_description);
  664.                                            set(filestring,  MUIA_String_Contents,key->h_filename); 
  665.                                           }
  666.                                          }
  667.                                          break;
  668.    case ID_OPENWD                      : OPENWD_MACRO;
  669.                                          break;
  670.    case ID_FILEREQ                     : {
  671.                                           ULONG o;
  672.                                           get(window,MUIA_Window_Open,&o);
  673.                                           if(!o)
  674.                                           {
  675.                                            UBYTE filename[STRMAXLEN];
  676.                                            struct Window *active_wd;
  677.                                            active_wd =  IntuitionBase->ActiveWindow;
  678.                                            if(!from_inside)
  679.                                            {
  680.                                             if(showrequest())
  681.                                             {
  682.                                              strncpy(filename,requestpath,STRMAXLEN);
  683.                                              AddPart(filename,requestfile,STRMAXLEN);
  684.                                              ScreenToFront(active_wd->WScreen);
  685.                                              ActivateWindow(active_wd);
  686.                                              if(!Sendfile(filename,GET_A_FILE))DoMethod(app,MUIM_Application_ReturnID,ID_QUIT_SILENT);
  687.                                             }
  688.                                            }
  689.                                           }
  690.                                          }
  691.                                          break;
  692.    case ID_DOUBLESTART                 : OPENWD_MACRO;
  693.                                          break;
  694.    case ID_RECSTART                    : {
  695.                                           ULONG o;
  696.                                           LONG n;
  697.                                           get(window,MUIA_Window_Open,&o);
  698.                                           get(rec_max,MUIA_String_Integer,&n);
  699.                                           if(!o)rec_start_f((n + 1));
  700.                                          }
  701.                                          break;
  702.    case ID_RECSTOP                     : {
  703.                                           rec_stop_f(NULL);
  704.                                          }
  705.                                          break;   
  706.    case ID_EDITFILE                    : {
  707.                                           UBYTE *o;
  708.                                           get(filestring,MUIA_String_Contents,&o);
  709.                                           editfile(o);
  710.                                          }
  711.                                          break; 
  712.    case ID_EDIT_RECFILE                :{
  713.                                          UBYTE *o;
  714.                                          get(rec_file,MUIA_String_Contents,&o);
  715.                                          editfile(o);
  716.                                          }
  717.                                          break; 
  718.    case ID_CHANGE_HANDLER_PRI          : exit_recorder();
  719.                                          init_recorder();
  720.                                          break;
  721.    case ID_AUTORECSTART                : set(press_a_key,MUIA_Window_Open,TRUE);
  722.                                          from_main = TRUE;
  723.                                          from_main_object = rec_start;
  724.                                          rec_start_f(1);
  725.                                          break;
  726.    case ID_AUTORECSTOP                 : set(press_a_key,MUIA_Window_Open,TRUE);
  727.                                          from_main = TRUE;
  728.                                          from_main_object = rec_stop;
  729.                                          rec_start_f(1);
  730.                                          break;
  731.    case ID_AUTOHOTKEY                  : set(press_a_key,MUIA_Window_Open,TRUE);
  732.                                          from_main = TRUE;
  733.                                          from_main_object = newkeystring;
  734.                                          rec_start_f(1);
  735.                                          break;
  736.    case ID_AUTOFILEREQKEY              : set(press_a_key,MUIA_Window_Open,TRUE);
  737.                                          from_main = TRUE;
  738.                                          from_main_object = filerequest_string;
  739.                                          rec_start_f(1);
  740.                                          break;
  741.  
  742.    case ID_AUTOPOPKEY                  : set(press_a_key,MUIA_Window_Open,TRUE);
  743.                                          from_main = TRUE;
  744.                                          from_main_object = popup_string;
  745.                                          rec_start_f(1);
  746.                                          break;
  747.    case ID_AUTOSTOPKEY                 : set(press_a_key,MUIA_Window_Open,TRUE);
  748.                                          from_main = TRUE;
  749.                                          from_main_object = stop_string;
  750.                                          rec_start_f(1);
  751.                                          break;
  752.  
  753.    case ID_AUTOINFOKEY                 : set(press_a_key,MUIA_Window_Open,TRUE);
  754.                                          from_main = TRUE;
  755.                                          from_main_object = info_string;
  756.                                          rec_start_f(1);
  757.                                          break;
  758.    default                             : break;
  759.   }
  760.   if (running && signals) 
  761.   {
  762.    ULONG sgs;
  763.    sgs = Wait(signals | (1L << SigBit));
  764.    if(sgs & (1L << SigBit))
  765.    {
  766.     if(from_main)
  767.     {
  768.      FILE  *file;
  769.      UBYTE buffer[STRMAXLEN];
  770.      rec_stop_f("ram:ascs.key.tmp");
  771.      from_main = FALSE;
  772.      set(press_a_key,MUIA_Window_Open,FALSE);
  773.      if(file = fopen("ram:ascs.key.tmp","r"))
  774.      {
  775.       fgets(buffer,STRMAXLEN,file);
  776.       if(from_main_object)
  777.       { 
  778.        UBYTE *p = buffer;
  779.        if(*buffer == '<')
  780.        {
  781.         p++;
  782.         *(buffer + strlen(buffer) - 1 ) = 0;
  783.        }
  784.        set(from_main_object,MUIA_String_Contents,p);
  785.        if(from_main_object == filerequest_string) ChangeKey(special_list,p,NULL,CXID_FILEREQ,MODE_CHANGE);
  786.        if(from_main_object == popup_string)      {ChangeKey(special_list,p,NULL,CXID_POPUP,MODE_CHANGE);
  787.                                                    ShowWDTitle();}
  788.        if(from_main_object ==  stop_string)       ChangeKey(special_list,p,NULL,CXID_STOP,MODE_CHANGE);
  789.        if(from_main_object ==  info_string)       ChangeKey(special_list,p,NULL,CXID_INFO,MODE_CHANGE);
  790.        if(from_main_object ==  rec_start)         ChangeKey(special_list,p,NULL,CXID_RECSTART,MODE_CHANGE);
  791.        if(from_main_object ==  rec_stop)          ChangeKey(special_list,p,NULL,CXID_RECSTOP,MODE_CHANGE);
  792.        from_main_object = NULL;
  793.       }
  794.       fclose(file);
  795.      }
  796.     }
  797.     else 
  798.     {
  799.      rec_stop_f(NULL);
  800.      DisplayBeep(0);
  801.     }
  802.    }
  803.   }
  804.  }
  805.  CLOSEWD_MACRO;
  806.  fail(app);
  807. }
  808.  
  809. /*******************************************************************/
  810. /*                Icon-Tooltypes laden                             */
  811. /*******************************************************************/
  812.  
  813. void __regargs Load_from_icon(int argc, char **argv)
  814. {
  815.  char **tooltypes = ArgArrayInit(argc,argv);
  816.  struct MsgPort *port   = NULL;
  817.  CxObj          *broker = NULL;
  818.  ULONG           i      = 0;
  819.  BOOL            end    = FALSE;
  820.  get(app,MUIA_Application_BrokerPort,&port);
  821.  get(app,MUIA_Application_Broker    ,&broker);
  822.  if(port && broker)
  823.  {
  824.   DoMethod(special_list,MUIM_List_Clear);
  825.   DoMethod(key_list,MUIM_List_Clear);
  826.   tooltypes = ArgArrayInit(argc,argv);
  827.   /*******************************/
  828.   /*     popkey                  */
  829.   /*******************************/
  830.   ChangeKey(special_list,ArgString(tooltypes,"CX_POPKEY","control alt a"),NULL,CXID_POPUP,MODE_NEW);
  831.   set(popup_string,MUIA_String_Contents,insert_key->h_description);
  832.   /*******************************/
  833.   /*     infokey                 */
  834.   /*******************************/
  835.   ChangeKey(special_list,ArgString(tooltypes,"INFOKEY","control alt i"),NULL,CXID_INFO,MODE_NEW);   
  836.   set(info_string,MUIA_String_Contents,insert_key->h_description);
  837.   /*******************************/
  838.   /*     filerequester           */
  839.   /*******************************/
  840.   ChangeKey(special_list,ArgString(tooltypes,"REQUESTKEY","control alt r"),NULL,CXID_FILEREQ,MODE_NEW);
  841.   set(filerequest_string,MUIA_String_Contents,insert_key->h_description);
  842.   /*******************************/
  843.   /*     stopkey                 */
  844.   /*******************************/
  845.   ChangeKey(special_list,ArgString(tooltypes,"STOPKEY","control alt q"),NULL,CXID_STOP,MODE_NEW);
  846.   set(stop_string,MUIA_String_Contents,insert_key->h_description);
  847.   /*******************************/
  848.   /*          recstart           */
  849.   /*******************************/
  850.   ChangeKey(special_list,ArgString(tooltypes,"RECSTARTKEY","control alt 8"),NULL,CXID_RECSTART,MODE_NEW);
  851.   set(rec_start,MUIA_String_Contents,insert_key->h_description);
  852.   /*******************************/
  853.   /*          recstop            */
  854.   /*******************************/
  855.   ChangeKey(special_list,ArgString(tooltypes,"RECSTOPKEY","control alt 9"),NULL,CXID_RECSTOP,MODE_NEW);
  856.   set(rec_stop,MUIA_String_Contents,insert_key->h_description);
  857.   /*******************************/
  858.   /*        filerequester        */
  859.   /*******************************/
  860.   strcpy(requestpath,ArgString(tooltypes,"REQPATH",""));
  861.   strcpy(requestfile,ArgString(tooltypes,"REQFILE",""));
  862.   set(edit_string,MUIA_String_Contents,ArgString(tooltypes,"EDITOR","GoldEd"));
  863.   set(rec_file,MUIA_String_Contents,ArgString(tooltypes,"RECFILE","ram:ascs_rec.0"));
  864.   for(;!end;i++)
  865.   {
  866.    UBYTE desc[KEYLEN];
  867.    UBYTE file[KEYLEN];
  868.    sprintf(desc,"HOTKEY%ld",i);
  869.    sprintf(file, "FILE%ld",  i);
  870.    if(ArgString(tooltypes,desc,NULL))
  871.    {
  872.     if(ArgString(tooltypes,file,NULL))
  873.     {
  874.      ChangeKey(key_list,ArgString(tooltypes,desc,NULL),ArgString(tooltypes,file,NULL),NextID,MODE_NEW);
  875.     }
  876.    }
  877.    else end = TRUE;
  878.   }    
  879.  }
  880.  set(delay_int,MUIA_String_Integer, ArgInt(tooltypes,"DELAY",12));
  881.  set(delaychar_int,MUIA_String_Integer, ArgInt(tooltypes,"DELAYCHAR",0));
  882.  set(rec_max,MUIA_String_Integer, ArgInt(tooltypes,"REC_MAXCHAR",0));
  883.  set(rec_min_delay,MUIA_String_Integer, ArgInt(tooltypes,"MIN_DELAY",25));
  884.  set(rec_handler_pri,MUIA_String_Integer, ArgInt(tooltypes,"HANDLER_PRIORITY",60));
  885.  if(!stricmp(ArgString(tooltypes,"INCLUDE_MB","NO"),"YES"))
  886.    set(rec_include_mb,MUIA_Selected,TRUE);
  887.  else
  888.    set(rec_include_mb,MUIA_Selected,FALSE);
  889.  if(!stricmp(ArgString(tooltypes,"INCLUDE_DELAY","NO"),"YES"))
  890.    set(rec_include_delay,MUIA_Selected,TRUE);
  891.  else
  892.    set(rec_include_delay,MUIA_Selected,FALSE);
  893.  if(!stricmp(ArgString(tooltypes,"REC_MAX_ON","NO"),"YES"))
  894.    set(rec_max_on,MUIA_Selected,TRUE);
  895.  else
  896.    set(rec_max_on,MUIA_Selected,FALSE);
  897.  
  898.  if(!stricmp(ArgString(tooltypes,"CX_POPUP","no"),"yes"))OPENWD_MACRO;
  899.  if(tooltypes)ArgArrayDone();
  900. }
  901.  
  902. /*********************************************************************/
  903. /*                Hook-Funktionen                                    */
  904. /*********************************************************************/
  905.  
  906. LONG __asm __saveds construct_key_func( register __a0 struct Hook *hook,register __a2 APTR m_pool,register __a1 struct hotkey *key)
  907. {
  908.  struct hotkey  *insert;
  909.  struct MsgPort *port   = NULL;
  910.  CxObj          *broker;
  911.  UBYTE          *p;
  912.  get(app,MUIA_Application_BrokerPort,&port);
  913.  get(app,MUIA_Application_Broker,&broker);
  914.  p = key->h_description  + strlen(key->h_description) - 1;
  915.  while(*p == ' '){*p = 0;--p;}
  916.  if(insert = (struct hotkey *)AllocVec(sizeof(struct hotkey),MEMF_PUBLIC | MEMF_CLEAR))
  917.  {
  918.   strncpy(insert->h_description,key->h_description,KEYLEN);
  919.   strncpy(insert->h_filename,key->h_filename,KEYLEN);
  920.   insert->h_id = key->h_id;
  921.   if(insert->h_key = HotKey(insert->h_description,port,insert->h_id))
  922.   {
  923.    AttachCxObj(broker,insert->h_key); 
  924.    NextID++;
  925.    return (LONG)insert;
  926.   }
  927.   else
  928.    FreeVec(insert);
  929.  }   
  930.  return (NULL);
  931. }
  932.  
  933. void __asm __saveds destruct_key_func( register __a0 struct Hook *hook,register __a2 APTR m_pool,register __a1 struct hotkey *key)
  934. {
  935.  if(key)
  936.  {
  937.   if(key->h_key)DeleteCxObjAll(key->h_key);
  938.   FreeVec(key);
  939.  }
  940. }
  941.  
  942. LONG __asm __saveds display_key_func(register __a0 struct Hook *hook,register __a2 UBYTE **array,register __a1 struct hotkey  *key)
  943. {
  944.  strcpy(displayline,key->h_description);
  945.  *array = displayline;
  946.  return (0);
  947. }
  948.  
  949. LONG __asm __saveds cxmsg_broker_func(register __a2 APTR app,register __a1 CxMsg *msg)
  950. {
  951.  LONG id,type;
  952.  CxObj *broker;
  953.  id    = CxMsgID(msg);
  954.  type  = CxMsgType(msg);
  955.  get(app,MUIA_Application_Broker,&broker);
  956.  switch(type)
  957.  {
  958.   case CXM_IEVENT   : switch(id)
  959.                       {
  960.                        case CXID_STOP       : DoMethod(app,MUIM_Application_ReturnID,ID_STOPKEY);
  961.                                               break;
  962.                        case CXID_INFO       : if(MUI_RequestA(app,NULL,0,NULL,GETSTR(32),"\33c" ASCSEND_VERSION "\n FREEWARE by Lunqual%%MAB@wsb.freinet.de\n",NULL) != 0)
  963.                                                DoMethod(app,MUIM_Application_ReturnID,ID_QUIT);
  964.                                               break;
  965.                        case CXID_POPUP      : OPENWD_MACRO;
  966.                                               DoMethod(app,MUIM_Application_ReturnID,ID_STOPKEY);
  967.                                               break;
  968.                        case CXID_FILEREQ    : DoMethod(app,MUIM_Application_ReturnID,ID_FILEREQ);
  969.                                               break;
  970.                        case CXID_RECSTART   : 
  971.                                               {
  972.                                                LONG n;
  973.                                                get(rec_max,MUIA_String_Integer,&n);
  974.                                                rec_start_f((n + 1));
  975.                                               }       
  976.                                               break;
  977.                        case CXID_RECSTOP    : {
  978.                                                rec_stop_f(NULL);
  979.                                               }
  980.                                               break;
  981.                        default              : {
  982.                                                struct hotkey *key;
  983.                                                if(key = FindEntry(key_list,id))
  984.                                                {
  985.                                                 if(!from_inside)
  986.                                                 {
  987.                                                  if(!Sendfile(key->h_filename,GET_A_FILE))
  988.                                                   DoMethod(app,MUIM_Application_ReturnID,ID_QUIT_SILENT);
  989.                                                 }
  990.                                                }
  991.                                               }
  992.                                               break;
  993.                       }
  994.                       break;
  995.   case CXM_COMMAND  : switch(id)
  996.                       {
  997.                        case CXCMD_DISABLE   : ActivateCxObj(broker,0L);
  998.                                               set(app,MUIA_Application_Iconified,TRUE);
  999.                                               break;
  1000.                        case CXCMD_ENABLE    : ActivateCxObj(broker,1L);
  1001.                                               set(app,MUIA_Application_Iconified,FALSE);
  1002.                                               break;
  1003.                        case CXCMD_KILL      : DoMethod(app,MUIM_Application_ReturnID,ID_QUIT);
  1004.                                               break;
  1005.                        case CXCMD_UNIQUE    : 
  1006.                        case CXCMD_APPEAR    : OPENWD_MACRO;
  1007.                                               break;
  1008.                        case CXCMD_DISAPPEAR : CLOSEWD_MACRO;
  1009.                                               break;
  1010.  
  1011.                        default     : break;
  1012.                       }
  1013.                        break;     
  1014.   default           : break;
  1015.  }
  1016.  return 0;
  1017. }
  1018.  
  1019.  
  1020. LONG __asm __saveds compare_func(register __a0 struct Hook *hook,register __a1 struct hotkey *h1,register __a2 struct hotkey *h2)
  1021. {
  1022.  return (h1->h_id == h2->h_id) ? 0 : (h1->h_id < h2->h_id) ? 1 : -1;
  1023. }
  1024.  
  1025. /*****************************************************************/
  1026. /*                Arexx-Hook-Funktionen                          */
  1027. /*****************************************************************/
  1028.  
  1029. LONG __asm __saveds rx_send_func(register __a1 UBYTE **parms)
  1030. {
  1031.  ULONG o;
  1032.  get(window,MUIA_Window_Open,&o);
  1033.  if((!o) && (!from_inside))
  1034.  {
  1035.   if(!Sendfile(*parms,GET_A_FILE)) DoMethod(app,MUIM_Application_ReturnID,ID_QUIT_SILENT);
  1036.  }
  1037.  return 0;
  1038. }
  1039.  
  1040. LONG __asm __saveds rx_activate_func(register __a1 UBYTE **parms)
  1041. {
  1042.  LONG rc = RC_ERROR;
  1043.  ULONG i_lock;
  1044.  struct Window *wd;
  1045.  struct Screen *sc;
  1046.  int end = FALSE;
  1047.  i_lock = LockIBase(0);
  1048.  sc = IntuitionBase->FirstScreen;
  1049.  while(sc && !end)
  1050.  {
  1051.   wd = sc->FirstWindow;
  1052.   while(wd && !end)
  1053.   {
  1054.    if(!strnicmp(*parms,wd->Title,strlen(*parms)))
  1055.    {
  1056.     end = TRUE;
  1057.     rc = RC_OK;
  1058.     UnlockIBase(i_lock);i_lock = 0;
  1059.     ScreenToFront(sc);
  1060.     ActivateWindow(wd);
  1061.    }
  1062.    wd = wd->NextWindow;
  1063.   }
  1064.   sc = sc->NextScreen;
  1065.  }
  1066.  if(i_lock)UnlockIBase(i_lock);
  1067.  return rc; 
  1068. }
  1069.  
  1070. LONG __asm __saveds rx_activate_screen_func(register __a1 UBYTE **parms)
  1071. {
  1072.  LONG rc = RC_ERROR;
  1073.  ULONG i_lock;
  1074.  struct Window *wd;
  1075.  struct Screen *sc;
  1076.  int end = FALSE;
  1077.  i_lock = LockIBase(0);
  1078.  sc = IntuitionBase->FirstScreen;
  1079.  while(sc && !end)
  1080.  {
  1081.   if(!strnicmp(*parms,sc->Title,strlen(*parms)))
  1082.   {
  1083.    end = TRUE;
  1084.    ScreenToFront(sc);
  1085.    if(wd = sc->FirstWindow)
  1086.    {
  1087.     rc = RC_OK;
  1088.    }
  1089.   }
  1090.   sc = sc->NextScreen;
  1091.  }
  1092.  UnlockIBase(i_lock);
  1093.  if(rc == RC_OK) ActivateWindow(wd);
  1094.  return rc;     
  1095. }
  1096.  
  1097. LONG __asm __saveds rx_setkey_func(register __a1 UBYTE **parms)
  1098. {
  1099.  UBYTE **p;
  1100.  struct hotkey *k;
  1101.  UBYTE key[STRMAXLEN];
  1102.  *key = 0;
  1103.  p = (UBYTE **)parms[1];
  1104.  while(*p)
  1105.  {
  1106.   strcat(key,*p);strcat(key," ");
  1107.   p++;
  1108.  }
  1109.  *(key + (KEYLEN-1)) = 0; 
  1110.  set(newkeystring,MUIA_String_Contents,key);
  1111.  set(filestring  ,MUIA_String_Contents,parms[0]);
  1112.  if(k = FindEntryKey(key_list,key))
  1113.  {
  1114.   strcpy(k->h_filename,parms[0]);
  1115.  }
  1116.  else
  1117.   ChangeKey(key_list,key,parms[0],NextID,MODE_CHANGE);
  1118.  return 0;   
  1119. }
  1120.  
  1121. LONG __asm __saveds rx_remkey_func(register __a1 UBYTE **parms)
  1122. {
  1123.  UBYTE **p;
  1124.  struct hotkey *k;
  1125.  UBYTE key[STRMAXLEN];
  1126.  *key = 0;
  1127.  p = (UBYTE **)parms[0];
  1128.  while(*p)
  1129.  {
  1130.   strcat(key,*p);strcat(key," ");
  1131.   p++;
  1132.  }
  1133.  *(key + (KEYLEN-1)) = 0; 
  1134.  if(k = FindEntryKey(key_list,key))
  1135.  {
  1136.   ChangeKey(key_list,NULL,NULL,k->h_id,MODE_CHANGE);
  1137.  }
  1138.  return (0);
  1139. }
  1140.  
  1141. LONG __asm __saveds rx_remall_func(register __a1 UBYTE **parms)
  1142. {
  1143.  DoMethod(key_list,MUIM_List_Clear);
  1144.  return (0);   
  1145. }
  1146.  
  1147. LONG __asm __saveds rx_set_func(register __a1 UBYTE **parms)
  1148. {
  1149.  UBYTE **p;
  1150.  UBYTE key[STRMAXLEN];
  1151.  LONG  id = -1;
  1152.  APTR  obj;
  1153.  *key = 0;
  1154.  p = (UBYTE **)parms[6];
  1155.  while(*p)
  1156.  {
  1157.   strcat(key,*p);strcat(key," ");
  1158.   p++;
  1159.  }
  1160.  *(key + (KEYLEN-1)) = 0; 
  1161.  if(parms[0]){id = CXID_POPUP   ;obj = popup_string;}
  1162.  if(parms[1]){id = CXID_FILEREQ ;obj = filerequest_string;}
  1163.  if(parms[2]){id = CXID_INFO    ;obj = info_string;}
  1164.  if(parms[3]){id = CXID_STOP    ;obj = stop_string;}
  1165.  if(parms[4]){id = CXID_RECSTART;obj = rec_start;}
  1166.  if(parms[5]){id = CXID_RECSTOP ;obj = rec_stop;}
  1167.  if(id != -1)
  1168.  {
  1169.   ChangeKey(special_list,key,NULL,id,MODE_CHANGE);
  1170.   set(obj,MUIA_String_Contents,key);
  1171.  }
  1172.  return (0);
  1173. }
  1174.  
  1175. LONG __asm __saveds rx_delay_func(register __a1 LONG **parms)
  1176. {
  1177.  set(delay_int,MUIA_String_Integer,*parms[0]);
  1178.  return (0);
  1179. }
  1180.  
  1181. LONG __asm __saveds rx_delaychar_func(register __a1 LONG **parms)
  1182. {
  1183.  set(delaychar_int,MUIA_String_Integer,*parms[0]);
  1184.  return (0);
  1185. }
  1186.  
  1187. LONG __asm __saveds rx_sendstring_func(register __a1 LONG **parms)
  1188. {
  1189.  UBYTE **p;
  1190.  UBYTE string[512];
  1191.  p = (UBYTE **)parms[0];
  1192.  *string = 0;
  1193.  while(*p)
  1194.  {
  1195.   strcat(string,*p);strcat(string," ");
  1196.   p++;
  1197.  }
  1198.  string[strlen(string)] = 0;
  1199.  Sendfile(string,GET_A_STRING);
  1200.  return (0);
  1201. }
  1202.  
  1203. LONG __asm __saveds rx_recfile_func(register __a1 LONG **parms)
  1204. {
  1205.  set(rec_file,MUIA_String_Contents,*parms[0]);
  1206.  return(0);
  1207. }
  1208.  
  1209. LONG __asm __saveds rx_rec_opts_func(register __a1 LONG **parms)
  1210. {
  1211.  if(parms[0])set(rec_min_delay,MUIA_String_Integer,*parms[0]);
  1212.  if(parms[1])
  1213.  {
  1214.   set(rec_handler_pri,MUIA_String_Integer,*parms[1]);
  1215.   exit_recorder();
  1216.   init_recorder();
  1217.  }
  1218.  if(parms[2])set(rec_include_mb,MUIA_Selected,TRUE);
  1219.    else      set(rec_include_mb,MUIA_Selected,FALSE);
  1220.  if(parms[3])set(rec_include_delay,MUIA_Selected,TRUE);
  1221.    else      set(rec_include_delay,MUIA_Selected,FALSE);
  1222.  if(parms[4])set(rec_max,MUIA_String_Integer,*parms[4]);
  1223.  if(parms[5])set(rec_max_on,MUIA_Selected,TRUE);
  1224.     else     set(rec_max_on,MUIA_Selected,FALSE);
  1225.  return(0);
  1226. }
  1227.  
  1228. /*********************************************************************/
  1229. /*                 sonstiger Krempel                                 */
  1230. /*********************************************************************/
  1231.  
  1232. struct hotkey __regargs *FindEntry(APTR list,ULONG id)
  1233. {
  1234.  struct hotkey *rc = NULL;
  1235.  ULONG          i;
  1236.  for(i=0;;i++)
  1237.  {
  1238.   DoMethod(list,MUIM_List_GetEntry,i,&rc);
  1239.   if(!rc)return NULL;
  1240.   if(rc->h_id == id)return rc;
  1241.  }
  1242. }
  1243.  
  1244. LONG __regargs FindEntryNumber(APTR list,ULONG id)
  1245. {
  1246.  struct hotkey *rc = NULL;
  1247.  LONG          i;
  1248.  for(i=0;;i++)
  1249.  {
  1250.   DoMethod(list,MUIM_List_GetEntry,i,&rc);
  1251.   if(!rc)return -1;
  1252.   if(rc->h_id == id)return i;
  1253.  }
  1254. } 
  1255.  
  1256. struct hotkey __regargs *FindEntryN(APTR list,ULONG num)
  1257. {
  1258.  struct hotkey *rc = NULL;
  1259.  LONG          i;
  1260.  for(i=0;i <= num;i++)
  1261.  {
  1262.   DoMethod(list,MUIM_List_GetEntry,i,&rc);
  1263.   if(!rc)return (NULL);
  1264.  }
  1265.  return (rc);
  1266. } 
  1267.  
  1268.  
  1269. struct hotkey __regargs *FindEntryKey(APTR list,UBYTE *key)
  1270. {
  1271.  struct hotkey *rc = NULL;
  1272.  LONG          i;
  1273.  for(i=0;;i++)
  1274.  {
  1275.   DoMethod(list,MUIM_List_GetEntry,i,&rc);
  1276.   if(!rc)return NULL;
  1277.   if(!strnicmp(key,rc->h_description,strlen(rc->h_description)))return rc;
  1278.  }
  1279. }
  1280.  
  1281. void ShowWDTitle()
  1282. {
  1283.  struct hotkey *key;
  1284.  if(key = FindEntry(special_list,CXID_POPUP))
  1285.  {
  1286.   strcpy(wtitle,"ASCII-SEND: Hotkey=");
  1287.   strcat(wtitle,key->h_description);
  1288.  } 
  1289.  set(window,MUIA_Window_Title,&wtitle);   
  1290. }
  1291.  
  1292. void __regargs ChangeKey(APTR list,UBYTE *key,UBYTE *file,ULONG id,ULONG mode)
  1293. {
  1294.  LONG rkey;
  1295.  if(mode == MODE_CHANGE)
  1296.  {
  1297.   if((rkey = FindEntryNumber(list,id)) != -1) DoMethod(list,MUIM_List_Remove,rkey);
  1298.  }
  1299.  if((key == NULL) &&(file == NULL))return;
  1300.  memset(insert_key,0,sizeof(struct hotkey));
  1301.  strcpy(insert_key->h_description,key);
  1302.  if(file) strcpy(insert_key->h_filename,file);
  1303.  insert_key->h_id = id;
  1304.  DoMethod(list,MUIM_List_Insert,&insert_key,1,MUIV_List_Insert_Bottom); 
  1305. }
  1306.  
  1307. UBYTE __regargs *makemem(ULONG size)
  1308. {
  1309.  return((UBYTE *)AllocVec(size,MEMF_PUBLIC | MEMF_CLEAR));   
  1310. }
  1311.  
  1312. void releasemem(void *mem)
  1313. {
  1314.  FreeVec(mem);   
  1315. }
  1316.  
  1317. UBYTE __regargs *getfilebuffer(UBYTE *filename,ULONG mode)
  1318. {
  1319.  struct FileInfoBlock *fib;
  1320.  BPTR lock,fh;
  1321.  UBYTE *buffer;
  1322.  switch( mode )
  1323.  {
  1324.   case GET_A_FILE: 
  1325.   if(lock = Lock(filename,ACCESS_READ))
  1326.   {
  1327.    if(fib = AllocDosObject(DOS_FIB,TAG_DONE))
  1328.    {
  1329.     Examine(lock,fib);
  1330.     filesize = fib->fib_Size;
  1331.     FreeDosObject(DOS_FIB,fib);
  1332.     if(buffer = (UBYTE *)makemem(filesize))
  1333.     {
  1334.      if(fh = OpenFromLock(lock))
  1335.      {
  1336.       FRead(fh,buffer,filesize,1);
  1337.       Close(fh);
  1338.       return buffer;
  1339.      }
  1340.      else UnLock(lock);
  1341.     }
  1342.    }
  1343.   }
  1344.   return NULL;
  1345.   break;
  1346.   case GET_A_STRING :
  1347.   filesize = strlen(filename + 1);
  1348.   if(buffer = (UBYTE *)makemem(filesize))
  1349.   {
  1350.    strcpy(buffer,filename);
  1351.    return buffer;
  1352.   }
  1353.   else return NULL;
  1354.   break;
  1355.  }    
  1356.  return NULL;
  1357. }
  1358.  
  1359. void __regargs freefilebuffer(UBYTE *buffer,ULONG size)
  1360. {
  1361.  releasemem(buffer);   
  1362. }
  1363.  
  1364. BOOL __regargs getnextchar(UBYTE *buffer,UBYTE *where)
  1365. {
  1366.  if(filepos >= filesize)return FALSE;
  1367.  *where = *(buffer + filepos);
  1368.  filepos++;   
  1369.  return TRUE;
  1370. }
  1371.  
  1372. void editfile(UBYTE *name)
  1373. {
  1374.  UBYTE line[STRMAXLEN];
  1375.  UBYTE *c;
  1376.  BPTR  in;
  1377.  if(in = Open("NIL:",ACCESS_READ))
  1378.  {
  1379.   get(edit_string,MUIA_String_Contents,&c);
  1380.   strcpy(line,c);strcat(line," ");
  1381.   strcat(line,name);
  1382.   SystemTags(line,SYS_Input,in,SYS_Asynch,TRUE,TAG_DONE);
  1383.  }
  1384. }
  1385.  
  1386. /*********************************************************************/
  1387. /*              Filerequester                                        */
  1388. /*********************************************************************/
  1389.  
  1390. int showrequest()
  1391. {
  1392.  int ret = FALSE;
  1393.  struct  FileRequester *FileReq;
  1394.  struct Screen         *rscreen;
  1395.  if(rscreen = LockPubScreen(NULL))ScreenToFront(rscreen);
  1396.  FRTags[3].ti_Data = (ULONG)requestpath;
  1397.  FRTags[4].ti_Data = (ULONG)requestfile;
  1398.  if(FileReq = (struct FileRequester *)MUI_AllocAslRequest(ASL_FileRequest,FRTags))
  1399.  {
  1400.   if(MUI_AslRequest(FileReq,TAG_DONE))
  1401.   {
  1402.    ret = TRUE;
  1403.    strcpy(requestfile,FileReq->rf_File);
  1404.    strcpy(requestpath,FileReq->rf_Dir);
  1405.   }
  1406.   MUI_FreeAslRequest((APTR)FileReq);
  1407.  }
  1408.  return ret;
  1409. }
  1410.  
  1411.  
  1412. /*********************************************************************/
  1413. /*             Datei senden                                          */
  1414. /*********************************************************************/
  1415.  
  1416. long __regargs Sendfile(UBYTE *filename,ULONG mode)
  1417. {
  1418.  int rc = TRUE;
  1419.  struct InputEvent *ie;
  1420.  UBYTE buffer[STRMAXLEN];
  1421.  UBYTE *filebuffer;
  1422.  int Ldelay     = FALSE;
  1423.  ULONG           stop = FALSE;
  1424.  ULONG           v_line;
  1425.  ULONG           v_z;
  1426.  ULONG           fpm;  
  1427.  ULONG           brk = IE_COUNT;  
  1428.  if(!makeIHandler())return rc;
  1429.  get(delay_int,MUIA_String_Integer,&v_line);
  1430.  get(delaychar_int,MUIA_String_Integer,&v_z);
  1431.  from_inside = TRUE;
  1432.  filepos = 0;
  1433.  if(filebuffer = getfilebuffer(filename,mode))
  1434.  {
  1435.   while((getnextchar(filebuffer,buffer)) && (!stop))
  1436.   {
  1437.    *(buffer + 1) = 0;
  1438.    switch(*buffer)
  1439.    {
  1440.     case '\n' : Ldelay = TRUE;
  1441.                 strcpy(buffer,"\\n");
  1442.                 break;
  1443.     case '\r' : Ldelay = TRUE;
  1444.                 strcpy(buffer,"\\r");
  1445.                 break;
  1446.     case '\t' : strcpy(buffer,"\\t");
  1447.                 break;
  1448.     case '\\' : fpm = filepos;
  1449.                 getnextchar(filebuffer,buffer + 1);
  1450.                 *(buffer + 2) = 0;
  1451.                 {
  1452.                  int end = FALSE;
  1453.                  int p = 2;
  1454.                  ULONG v;
  1455.                  if((*(buffer + 1)=='d')||(*(buffer + 1)=='l')||(*(buffer + 1)=='c')||
  1456.                     (*(buffer + 1)=='n')||(*(buffer + 1)=='r')||(*(buffer + 1)=='t'))
  1457.                  {
  1458.                   do
  1459.                   {
  1460.                    if( (*(buffer + 1)=='n')||(*(buffer + 1)=='r')||(*(buffer + 1)=='t'))
  1461.                    {
  1462.                     end = TRUE;
  1463.                    }
  1464.                    else
  1465.                    {
  1466.                     getnextchar(filebuffer,buffer + p);
  1467.                     if(!(isdigit(*(buffer + p))) || (p >= 6))
  1468.                     {
  1469.                      end = TRUE;
  1470.                      *(buffer + p + 1) = 0;
  1471.                      v = atol(buffer + 2);
  1472.                      switch(*(buffer + 1))
  1473.                      {
  1474.                       case 'd' : Delay(v);
  1475.                                  break;
  1476.                       case 'l' : v_line = v;
  1477.                                  break;
  1478.                       case 'c' : v_z = v;
  1479.                                  break;
  1480.                       default  : break;
  1481.                      }
  1482.                      *buffer = 0;
  1483.                      filepos -= 1;
  1484.                     }
  1485.                     p++;
  1486.                     if(p >= (STRMAXLEN - 2))end = TRUE;
  1487.                    }
  1488.                   }
  1489.                   while(!end); 
  1490.                  }
  1491.                  else
  1492.                  {
  1493.                   UBYTE t[2] = {0,0}; 
  1494.                   struct InputEvent ev;
  1495.                   if(*(buffer + 1) == '(')
  1496.                   {
  1497.                    getnextchar(filebuffer,buffer + 2);
  1498.                    getnextchar(filebuffer,buffer + 3);
  1499.                    getnextchar(filebuffer,buffer + 4);
  1500.                    getnextchar(filebuffer,buffer + 5);
  1501.                    if((*(buffer + 3) == 'm')&&(*(buffer + 5)==':'))
  1502.                    {
  1503.                     int p = 6;
  1504.                     int py;
  1505.                     int end = FALSE;
  1506.                     while(!end)
  1507.                     {
  1508.                      getnextchar(filebuffer,buffer + p);
  1509.                      if(!(isdigit(*(buffer + p))))
  1510.                      {
  1511.                       end = TRUE;
  1512.                      }
  1513.                      p++;
  1514.                     }
  1515.                     --p;
  1516.                     if(*(buffer + p) == ',')
  1517.                     {
  1518.                      p++;
  1519.                      py = p;
  1520.                      end = FALSE;
  1521.                      while(!end)
  1522.                      {
  1523.                       getnextchar(filebuffer,buffer + p);
  1524.                       if(!(isdigit(*(buffer + p))))
  1525.                       {
  1526.                        end = TRUE;
  1527.                       }
  1528.                       p++;
  1529.                      }
  1530.                      --p;
  1531.                      if(*(buffer + p) == ')')
  1532.                      {
  1533.                       ev.ie_Class = IECLASS_POINTERPOS;
  1534.                       ev.ie_NextEvent = NULL;
  1535.                       ev.ie_Qualifier = 0;
  1536.                       ev.ie_SubClass  = 0;
  1537.                       ev.ie_TimeStamp.tv_secs = 0;
  1538.                       ev.ie_TimeStamp.tv_micro = 0;
  1539.                       ev.ie_Y = (WORD)atol(buffer + py);
  1540.                       ev.ie_X = (WORD)atol(buffer + 6);
  1541.                       switch(*(buffer + 2))
  1542.                       {
  1543.                        case 'l' : if(*(buffer + 4) == 'd')
  1544.                                    ev.ie_Code      = IECODE_LBUTTON ;
  1545.                                   else
  1546.                                     ev.ie_Code      = IECODE_LBUTTON | IECODE_UP_PREFIX;
  1547.                                   my_AddIEvents(&ev);
  1548.                                   break;
  1549.                        case 'r' : if(*(buffer + 4) == 'd')
  1550.                                    ev.ie_Code      = IECODE_RBUTTON ;
  1551.                                   else
  1552.                                     ev.ie_Code      = IECODE_RBUTTON | IECODE_UP_PREFIX;
  1553.                                   my_AddIEvents(&ev);
  1554.                                   break;
  1555.                         case 'm' : if(*(buffer + 4) == 'd')
  1556.                                    ev.ie_Code      = IECODE_MBUTTON ;
  1557.                                   else
  1558.                                     ev.ie_Code      = IECODE_MBUTTON | IECODE_UP_PREFIX;
  1559.                                   my_AddIEvents(&ev);
  1560.                                   break;
  1561.                       }
  1562.                       *buffer = 0;
  1563.                      }
  1564.                      else
  1565.                      {
  1566.                       filepos =fpm;
  1567.                       strcpy(buffer,"\\\\");
  1568.                       if(ie = InvertString(buffer,NULL))
  1569.                       {
  1570.                        my_AddIEvents(ie);
  1571.                        FreeIEvents(ie);
  1572.                        *buffer = 0;
  1573.                       }
  1574.                      }
  1575.                     }
  1576.                     else
  1577.                     {
  1578.                      filepos = fpm;
  1579.                      strcpy(buffer,"\\\\");
  1580.                      if(ie = InvertString(buffer,NULL))
  1581.                      {
  1582.                       my_AddIEvents(ie);
  1583.                       FreeIEvents(ie);
  1584.                       *buffer = 0;
  1585.                      }
  1586.                     }
  1587.                    }
  1588.                    else
  1589.                    {
  1590.                     filepos = fpm;
  1591.                     strcpy(buffer,"\\\\");
  1592.                     if(ie = InvertString(buffer,NULL))
  1593.                     {
  1594.                      my_AddIEvents(ie);
  1595.                      FreeIEvents(ie);
  1596.                      *buffer = 0;
  1597.                     }
  1598.                    }
  1599.                   }
  1600.                   else
  1601.                   {
  1602.                    t[0] = *(buffer + 1);
  1603.                    strcpy(buffer,"\\\\");
  1604.                    if(ie = InvertString(buffer,NULL))
  1605.                    {
  1606.                     my_AddIEvents(ie);
  1607.                     FreeIEvents(ie);
  1608.                    }
  1609.                   }
  1610.                   strcpy(buffer,t);
  1611.                   switch(*buffer)
  1612.                   {
  1613.                    case '\n' : strcpy(buffer,"\\n");
  1614.                                break;
  1615.                    case '\r' : strcpy(buffer,"\\r");
  1616.                                break;
  1617.                    case '<'  : *buffer = 0;filepos -= 1;
  1618.                                break;
  1619.                   }
  1620.                  }
  1621.                 }
  1622.                 break;
  1623.    case '<'  : {
  1624.                  int end;
  1625.                  int p;
  1626.                  end = FALSE;
  1627.                  p = 1;
  1628.                  fpm = filepos;
  1629.                  do
  1630.                  {
  1631.                   getnextchar(filebuffer,buffer + p);
  1632.                   switch(*(buffer + p))
  1633.                   {
  1634.                    case '\r': 
  1635.                    case '\n': if(ie = InvertString("\\<",NULL))
  1636.                               {
  1637.                                my_AddIEvents(ie); 
  1638.                                FreeIEvents(ie);
  1639.                               }
  1640.                               filepos = fpm;
  1641.                               *buffer = 0;
  1642.                               end = TRUE;
  1643.                               break;
  1644.                    case '>' : *(buffer + p + 1) = 0;
  1645.                               if(ie = InvertString(buffer,NULL))
  1646.                               {
  1647.                                my_AddIEvents(ie); 
  1648.                                FreeIEvents(ie);
  1649.                               }
  1650.                               else
  1651.                               {
  1652.                                if(ie = InvertString("\\<",NULL))
  1653.                                {
  1654.                                 my_AddIEvents(ie); 
  1655.                                 FreeIEvents(ie);
  1656.                                }
  1657.                                filepos = fpm;
  1658.                               }
  1659.                               *buffer = 0;
  1660.                               end = TRUE;
  1661.                               break;
  1662.                    default  : break;
  1663.                   }
  1664.                   p++;
  1665.                   if(p >= (STRMAXLEN - 2))end = TRUE;
  1666.                  }
  1667.                  while(!end);
  1668.                  break;
  1669.                 }
  1670.     case '>'  : if(ie = InvertString(buffer,NULL))
  1671.                 {
  1672.                  my_AddIEvents(ie); 
  1673.                  FreeIEvents(ie);
  1674.                 }
  1675.                 strcpy(buffer,"\\>");
  1676.                 break;
  1677.     default   : *(buffer + 1) = 0;
  1678.                 break;
  1679.    }
  1680.    
  1681.    if(ie = InvertString(buffer,NULL))
  1682.    {
  1683.     --brk;
  1684.     if(v_z)Delay(v_z);
  1685.     my_AddIEvents(ie);
  1686.     FreeIEvents(ie);
  1687.     if(Ldelay)
  1688.     {
  1689.      Delay(v_line);
  1690.      Ldelay = FALSE;
  1691.      brk = 0;
  1692.     }
  1693.     if(!brk)
  1694.     {
  1695.      brk = IE_COUNT;
  1696.      switch(DoMethod(app,MUIM_Application_Input,&signals))
  1697.      {
  1698.       case MUIV_Application_ReturnID_Quit :
  1699.       case ID_QUIT                        : if(MUI_RequestA(app,NULL,0,NULL,"Ja|*Nein","\33cWollen Sie dieses\ngigantische Programm\nwirklich beenden ???",NULL) != 0)
  1700.                                             {
  1701.                                              stop = TRUE;
  1702.                                              rc = FALSE;
  1703.                                             }
  1704.                                             break;
  1705.       case ID_INFO                        : MUI_RequestA(app,NULL,0,NULL,"*Na gut","\33c" ASCSEND_VERSION "\n FREEWARE von Lunqual%%MAB@wsb.freinet.de\n",NULL);
  1706.                                             break;
  1707.       case ID_OPENWD                      : OPENWD_MACRO;
  1708.       case ID_STOPKEY                     : stop  = TRUE;
  1709.                                             break; 
  1710.       default                             : break;
  1711.      }
  1712.     }
  1713.    }
  1714.   }
  1715.   freefilebuffer(filebuffer,filesize);
  1716.  }
  1717.  from_inside=FALSE; 
  1718.  remIHandler();
  1719.  return rc;
  1720. }
  1721.  
  1722. /*********************************************************************/
  1723. /*                  InputHandler Glump                               */
  1724. /*********************************************************************/
  1725.  
  1726. LONG makeIHandler()
  1727. {
  1728.  if(s_InputPort = CreateMsgPort())
  1729.  {
  1730.   if(s_HandlerIO = (struct IOStdReq *)CreateExtIO(s_InputPort,sizeof(struct IOStdReq)))
  1731.   {
  1732.    if(!(s_device = OpenDevice("input.device",NULL,(struct IORequest *)s_HandlerIO,0L)))
  1733.    {
  1734.     s_HandlerIO->io_Length  = sizeof(struct InputEvent);
  1735.     s_HandlerIO->io_Command = IND_WRITEEVENT;
  1736.     return(TRUE);
  1737.    }
  1738.   }  
  1739.  }
  1740.  return (FALSE);
  1741. }
  1742.  
  1743. void remIHandler()
  1744. {
  1745.  if(s_HandlerIO)
  1746.  {
  1747.   if(!s_device)CloseDevice((struct IORequest *)s_HandlerIO);
  1748.   DeleteExtIO((struct IORequest *)s_HandlerIO);
  1749.   s_HandlerIO = NULL;
  1750.  }
  1751.  if(s_InputPort)
  1752.  {
  1753.   DeletePort(s_InputPort);
  1754.   s_InputPort = NULL;
  1755.  }
  1756. }
  1757.        
  1758. /*********************************************************************/
  1759. /*                  MUI init & Fail                                  */
  1760. /*********************************************************************/
  1761.  
  1762. void init()
  1763. {
  1764.  if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,7L)))fail(NULL);
  1765.  LocaleBase = OpenLibrary("locale.library",38);
  1766.  ascs_locale = OpenLocale(NULL);
  1767.  ascs_catalog = OpenCatalog(ascs_locale,"ascsend.catalog", 
  1768.                             OC_BuiltInLanguage,"deutsch",
  1769.                             OC_Version,1,TAG_DONE);
  1770.  menu_list[0].nm_Label = GETSTR(0);
  1771.  menu_list[1].nm_Label = GETSTR(1);
  1772.  menu_list[2].nm_Label = GETSTR(2);
  1773.  menu_list[4].nm_Label = GETSTR(3);
  1774.  menu_list[6].nm_Label = GETSTR(4);
  1775.  menu_list[7].nm_Label = GETSTR(5);
  1776.  FRTags[0].ti_Data     = (ULONG)GETSTR(6);
  1777. }
  1778.  
  1779. void __regargs fail(APTR app)
  1780. {
  1781.  if (app)
  1782.  {
  1783.   MUI_DisposeObject(app);
  1784.  }
  1785.  exit_recorder();
  1786.  if(LocaleBase)CloseLibrary(LocaleBase);
  1787.  CloseCatalog(ascs_catalog);
  1788.  CloseLocale(ascs_locale);
  1789.  if (MUIMasterBase)CloseLibrary(MUIMasterBase);
  1790.  exit(0);
  1791. }
  1792.  
  1793. /**********************************************************************/
  1794.  
  1795.  
  1796.  
  1797.